home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_iter.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  29.9 KB  |  1,140 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import unittest
  5. from test.test_support import run_unittest, TESTFN, unlink, have_unicode
  6. TRIPLETS = [
  7.     (0, 0, 0),
  8.     (0, 0, 1),
  9.     (0, 0, 2),
  10.     (0, 1, 0),
  11.     (0, 1, 1),
  12.     (0, 1, 2),
  13.     (0, 2, 0),
  14.     (0, 2, 1),
  15.     (0, 2, 2),
  16.     (1, 0, 0),
  17.     (1, 0, 1),
  18.     (1, 0, 2),
  19.     (1, 1, 0),
  20.     (1, 1, 1),
  21.     (1, 1, 2),
  22.     (1, 2, 0),
  23.     (1, 2, 1),
  24.     (1, 2, 2),
  25.     (2, 0, 0),
  26.     (2, 0, 1),
  27.     (2, 0, 2),
  28.     (2, 1, 0),
  29.     (2, 1, 1),
  30.     (2, 1, 2),
  31.     (2, 2, 0),
  32.     (2, 2, 1),
  33.     (2, 2, 2)]
  34.  
  35. class BasicIterClass:
  36.     
  37.     def __init__(self, n):
  38.         self.n = n
  39.         self.i = 0
  40.  
  41.     
  42.     def next(self):
  43.         res = self.i
  44.         if res >= self.n:
  45.             raise StopIteration
  46.         
  47.         self.i = res + 1
  48.         return res
  49.  
  50.  
  51.  
  52. class IteratingSequenceClass:
  53.     
  54.     def __init__(self, n):
  55.         self.n = n
  56.  
  57.     
  58.     def __iter__(self):
  59.         return BasicIterClass(self.n)
  60.  
  61.  
  62.  
  63. class SequenceClass:
  64.     
  65.     def __init__(self, n):
  66.         self.n = n
  67.  
  68.     
  69.     def __getitem__(self, i):
  70.         if i <= i:
  71.             pass
  72.         elif i < self.n:
  73.             return i
  74.         else:
  75.             raise IndexError
  76.  
  77.  
  78.  
  79. class TestCase(unittest.TestCase):
  80.     
  81.     def check_iterator(self, it, seq):
  82.         res = []
  83.         while None:
  84.             
  85.             try:
  86.                 val = it.next()
  87.             except StopIteration:
  88.                 break
  89.  
  90.         self.assertEqual(res, seq)
  91.  
  92.     
  93.     def check_for_loop(self, expr, seq):
  94.         res = []
  95.         for val in expr:
  96.             res.append(val)
  97.         
  98.         self.assertEqual(res, seq)
  99.  
  100.     
  101.     def test_iter_basic(self):
  102.         self.check_iterator(iter(range(10)), range(10))
  103.  
  104.     
  105.     def test_iter_idempotency(self):
  106.         seq = range(10)
  107.         it = iter(seq)
  108.         it2 = iter(it)
  109.         self.assert_(it is it2)
  110.  
  111.     
  112.     def test_iter_for_loop(self):
  113.         self.check_for_loop(iter(range(10)), range(10))
  114.  
  115.     
  116.     def test_iter_independence(self):
  117.         seq = range(3)
  118.         res = []
  119.         for i in iter(seq):
  120.             for j in iter(seq):
  121.                 for k in iter(seq):
  122.                     res.append((i, j, k))
  123.                 
  124.             
  125.         
  126.         self.assertEqual(res, TRIPLETS)
  127.  
  128.     
  129.     def test_nested_comprehensions_iter(self):
  130.         seq = range(3)
  131.         res = [ (i, j, k) for i in iter(seq) for j in iter(seq) for k in iter(seq) ]
  132.         self.assertEqual(res, TRIPLETS)
  133.  
  134.     
  135.     def test_nested_comprehensions_for(self):
  136.         seq = range(3)
  137.         res = [ (i, j, k) for i in seq for j in seq for k in seq ]
  138.         self.assertEqual(res, TRIPLETS)
  139.  
  140.     
  141.     def test_iter_class_for(self):
  142.         self.check_for_loop(IteratingSequenceClass(10), range(10))
  143.  
  144.     
  145.     def test_iter_class_iter(self):
  146.         self.check_iterator(iter(IteratingSequenceClass(10)), range(10))
  147.  
  148.     
  149.     def test_seq_class_for(self):
  150.         self.check_for_loop(SequenceClass(10), range(10))
  151.  
  152.     
  153.     def test_seq_class_iter(self):
  154.         self.check_iterator(iter(SequenceClass(10)), range(10))
  155.  
  156.     
  157.     def test_iter_callable(self):
  158.         
  159.         class C:
  160.             
  161.             def __init__(self):
  162.                 self.i = 0
  163.  
  164.             
  165.             def __call__(self):
  166.                 i = self.i
  167.                 self.i = i + 1
  168.                 if i > 100:
  169.                     raise IndexError
  170.                 
  171.                 return i
  172.  
  173.  
  174.         self.check_iterator(iter(C(), 10), range(10))
  175.  
  176.     
  177.     def test_iter_function(self):
  178.         
  179.         def spam(state = [
  180.             0]):
  181.             i = state[0]
  182.             state[0] = i + 1
  183.             return i
  184.  
  185.         self.check_iterator(iter(spam, 10), range(10))
  186.  
  187.     
  188.     def test_iter_function_stop(self):
  189.         
  190.         def spam(state = [
  191.             0]):
  192.             i = state[0]
  193.             if i == 10:
  194.                 raise StopIteration
  195.             
  196.             state[0] = i + 1
  197.             return i
  198.  
  199.         self.check_iterator(iter(spam, 20), range(10))
  200.  
  201.     
  202.     def test_exception_function(self):
  203.         
  204.         def spam(state = [
  205.             0]):
  206.             i = state[0]
  207.             state[0] = i + 1
  208.             if i == 10:
  209.                 raise RuntimeError
  210.             
  211.             return i
  212.  
  213.         res = []
  214.         
  215.         try:
  216.             for x in iter(spam, 20):
  217.                 res.append(x)
  218.         except RuntimeError:
  219.             self.assertEqual(res, range(10))
  220.  
  221.         self.fail('should have raised RuntimeError')
  222.  
  223.     
  224.     def test_exception_sequence(self):
  225.         
  226.         class MySequenceClass(SequenceClass):
  227.             
  228.             def __getitem__(self, i):
  229.                 if i == 10:
  230.                     raise RuntimeError
  231.                 
  232.                 return SequenceClass.__getitem__(self, i)
  233.  
  234.  
  235.         res = []
  236.         
  237.         try:
  238.             for x in MySequenceClass(20):
  239.                 res.append(x)
  240.         except RuntimeError:
  241.             self.assertEqual(res, range(10))
  242.  
  243.         self.fail('should have raised RuntimeError')
  244.  
  245.     
  246.     def test_stop_sequence(self):
  247.         
  248.         class MySequenceClass(SequenceClass):
  249.             
  250.             def __getitem__(self, i):
  251.                 if i == 10:
  252.                     raise StopIteration
  253.                 
  254.                 return SequenceClass.__getitem__(self, i)
  255.  
  256.  
  257.         self.check_for_loop(MySequenceClass(20), range(10))
  258.  
  259.     
  260.     def test_iter_big_range(self):
  261.         self.check_for_loop(iter(range(10000)), range(10000))
  262.  
  263.     
  264.     def test_iter_empty(self):
  265.         self.check_for_loop(iter([]), [])
  266.  
  267.     
  268.     def test_iter_tuple(self):
  269.         self.check_for_loop(iter((0, 1, 2, 3, 4, 5, 6, 7, 8, 9)), range(10))
  270.  
  271.     
  272.     def test_iter_xrange(self):
  273.         self.check_for_loop(iter(xrange(10)), range(10))
  274.  
  275.     
  276.     def test_iter_string(self):
  277.         self.check_for_loop(iter('abcde'), [
  278.             'a',
  279.             'b',
  280.             'c',
  281.             'd',
  282.             'e'])
  283.  
  284.     if have_unicode:
  285.         
  286.         def test_iter_unicode(self):
  287.             self.check_for_loop(iter(unicode('abcde')), [
  288.                 unicode('a'),
  289.                 unicode('b'),
  290.                 unicode('c'),
  291.                 unicode('d'),
  292.                 unicode('e')])
  293.  
  294.     
  295.     
  296.     def test_iter_dict(self):
  297.         dict = { }
  298.         for i in range(10):
  299.             dict[i] = None
  300.         
  301.         self.check_for_loop(dict, dict.keys())
  302.  
  303.     
  304.     def test_iter_file(self):
  305.         f = open(TESTFN, 'w')
  306.         
  307.         try:
  308.             for i in range(5):
  309.                 f.write('%d\n' % i)
  310.         finally:
  311.             f.close()
  312.  
  313.         f = open(TESTFN, 'r')
  314.         
  315.         try:
  316.             self.check_for_loop(f, [
  317.                 '0\n',
  318.                 '1\n',
  319.                 '2\n',
  320.                 '3\n',
  321.                 '4\n'])
  322.             self.check_for_loop(f, [])
  323.         finally:
  324.             f.close()
  325.             
  326.             try:
  327.                 unlink(TESTFN)
  328.             except OSError:
  329.                 pass
  330.  
  331.  
  332.  
  333.     
  334.     def test_builtin_list(self):
  335.         self.assertEqual(list(SequenceClass(5)), range(5))
  336.         self.assertEqual(list(SequenceClass(0)), [])
  337.         self.assertEqual(list(()), [])
  338.         self.assertEqual(list(range(10, -1, -1)), range(10, -1, -1))
  339.         d = {
  340.             'one': 1,
  341.             'two': 2,
  342.             'three': 3 }
  343.         self.assertEqual(list(d), d.keys())
  344.         self.assertRaises(TypeError, list, list)
  345.         self.assertRaises(TypeError, list, 42)
  346.         f = open(TESTFN, 'w')
  347.         
  348.         try:
  349.             for i in range(5):
  350.                 f.write('%d\n' % i)
  351.         finally:
  352.             f.close()
  353.  
  354.         f = open(TESTFN, 'r')
  355.         
  356.         try:
  357.             self.assertEqual(list(f), [
  358.                 '0\n',
  359.                 '1\n',
  360.                 '2\n',
  361.                 '3\n',
  362.                 '4\n'])
  363.             f.seek(0, 0)
  364.             self.assertEqual(list(f), [
  365.                 '0\n',
  366.                 '1\n',
  367.                 '2\n',
  368.                 '3\n',
  369.                 '4\n'])
  370.         finally:
  371.             f.close()
  372.             
  373.             try:
  374.                 unlink(TESTFN)
  375.             except OSError:
  376.                 pass
  377.  
  378.  
  379.  
  380.     
  381.     def test_builtin_tuple(self):
  382.         self.assertEqual(tuple(SequenceClass(5)), (0, 1, 2, 3, 4))
  383.         self.assertEqual(tuple(SequenceClass(0)), ())
  384.         self.assertEqual(tuple([]), ())
  385.         self.assertEqual(tuple(()), ())
  386.         self.assertEqual(tuple('abc'), ('a', 'b', 'c'))
  387.         d = {
  388.             'one': 1,
  389.             'two': 2,
  390.             'three': 3 }
  391.         self.assertEqual(tuple(d), tuple(d.keys()))
  392.         self.assertRaises(TypeError, tuple, list)
  393.         self.assertRaises(TypeError, tuple, 42)
  394.         f = open(TESTFN, 'w')
  395.         
  396.         try:
  397.             for i in range(5):
  398.                 f.write('%d\n' % i)
  399.         finally:
  400.             f.close()
  401.  
  402.         f = open(TESTFN, 'r')
  403.         
  404.         try:
  405.             self.assertEqual(tuple(f), ('0\n', '1\n', '2\n', '3\n', '4\n'))
  406.             f.seek(0, 0)
  407.             self.assertEqual(tuple(f), ('0\n', '1\n', '2\n', '3\n', '4\n'))
  408.         finally:
  409.             f.close()
  410.             
  411.             try:
  412.                 unlink(TESTFN)
  413.             except OSError:
  414.                 pass
  415.  
  416.  
  417.  
  418.     
  419.     def test_builtin_filter(self):
  420.         self.assertEqual(filter(None, SequenceClass(5)), range(1, 5))
  421.         self.assertEqual(filter(None, SequenceClass(0)), [])
  422.         self.assertEqual(filter(None, ()), ())
  423.         self.assertEqual(filter(None, 'abc'), 'abc')
  424.         d = {
  425.             'one': 1,
  426.             'two': 2,
  427.             'three': 3 }
  428.         self.assertEqual(filter(None, d), d.keys())
  429.         self.assertRaises(TypeError, filter, None, list)
  430.         self.assertRaises(TypeError, filter, None, 42)
  431.         
  432.         class Boolean:
  433.             
  434.             def __init__(self, truth):
  435.                 self.truth = truth
  436.  
  437.             
  438.             def __nonzero__(self):
  439.                 return self.truth
  440.  
  441.  
  442.         bTrue = Boolean(1)
  443.         bFalse = Boolean(0)
  444.         
  445.         class Seq:
  446.             
  447.             def __init__(self, *args):
  448.                 self.vals = args
  449.  
  450.             
  451.             def __iter__(self):
  452.                 
  453.                 class SeqIter:
  454.                     
  455.                     def __init__(self, vals):
  456.                         self.vals = vals
  457.                         self.i = 0
  458.  
  459.                     
  460.                     def __iter__(self):
  461.                         return self
  462.  
  463.                     
  464.                     def next(self):
  465.                         i = self.i
  466.                         self.i = i + 1
  467.                         if i < len(self.vals):
  468.                             return self.vals[i]
  469.                         else:
  470.                             raise StopIteration
  471.  
  472.  
  473.                 return SeqIter(self.vals)
  474.  
  475.  
  476.         seq = Seq(*[
  477.             bTrue,
  478.             bFalse] * 25)
  479.         self.assertEqual(filter((lambda x: not x), seq), [
  480.             bFalse] * 25)
  481.         self.assertEqual(filter((lambda x: not x), iter(seq)), [
  482.             bFalse] * 25)
  483.  
  484.     
  485.     def test_builtin_max_min(self):
  486.         self.assertEqual(max(SequenceClass(5)), 4)
  487.         self.assertEqual(min(SequenceClass(5)), 0)
  488.         self.assertEqual(max(8, -1), 8)
  489.         self.assertEqual(min(8, -1), -1)
  490.         d = {
  491.             'one': 1,
  492.             'two': 2,
  493.             'three': 3 }
  494.         self.assertEqual(max(d), 'two')
  495.         self.assertEqual(min(d), 'one')
  496.         self.assertEqual(max(d.itervalues()), 3)
  497.         self.assertEqual(min(iter(d.itervalues())), 1)
  498.         f = open(TESTFN, 'w')
  499.         
  500.         try:
  501.             f.write('medium line\n')
  502.             f.write('xtra large line\n')
  503.             f.write('itty-bitty line\n')
  504.         finally:
  505.             f.close()
  506.  
  507.         f = open(TESTFN, 'r')
  508.         
  509.         try:
  510.             self.assertEqual(min(f), 'itty-bitty line\n')
  511.             f.seek(0, 0)
  512.             self.assertEqual(max(f), 'xtra large line\n')
  513.         finally:
  514.             f.close()
  515.             
  516.             try:
  517.                 unlink(TESTFN)
  518.             except OSError:
  519.                 pass
  520.  
  521.  
  522.  
  523.     
  524.     def test_builtin_map(self):
  525.         self.assertEqual(map(None, SequenceClass(5)), range(5))
  526.         self.assertEqual(map((lambda x: x + 1), SequenceClass(5)), range(1, 6))
  527.         d = {
  528.             'one': 1,
  529.             'two': 2,
  530.             'three': 3 }
  531.         self.assertEqual(map(None, d), d.keys())
  532.         self.assertEqual(map((lambda k, d = d: (k, d[k])), d), d.items())
  533.         dkeys = d.keys()
  534.         expected = [ (None, i, None) for i in range(5) ]
  535.         self.assertEqual(map(None, d, SequenceClass(5), iter(d.iterkeys())), expected)
  536.         f = open(TESTFN, 'w')
  537.         
  538.         try:
  539.             for i in range(10):
  540.                 f.write('xy' * i + '\n')
  541.         finally:
  542.             f.close()
  543.  
  544.         f = open(TESTFN, 'r')
  545.         
  546.         try:
  547.             self.assertEqual(map(len, f), range(1, 21, 2))
  548.         finally:
  549.             f.close()
  550.             
  551.             try:
  552.                 unlink(TESTFN)
  553.             except OSError:
  554.                 []
  555.                 []
  556.  
  557.  
  558.  
  559.     
  560.     def test_builtin_zip(self):
  561.         self.assertEqual(zip(), [])
  562.         self.assertEqual(zip(*[]), [])
  563.         self.assertEqual(zip(*[
  564.             (1, 2),
  565.             'ab']), [
  566.             (1, 'a'),
  567.             (2, 'b')])
  568.         self.assertRaises(TypeError, zip, None)
  569.         self.assertRaises(TypeError, zip, range(10), 42)
  570.         self.assertRaises(TypeError, zip, range(10), zip)
  571.         self.assertEqual(zip(IteratingSequenceClass(3)), [
  572.             (0,),
  573.             (1,),
  574.             (2,)])
  575.         self.assertEqual(zip(SequenceClass(3)), [
  576.             (0,),
  577.             (1,),
  578.             (2,)])
  579.         d = {
  580.             'one': 1,
  581.             'two': 2,
  582.             'three': 3 }
  583.         self.assertEqual(d.items(), zip(d, d.itervalues()))
  584.         
  585.         class IntsFrom:
  586.             
  587.             def __init__(self, start):
  588.                 self.i = start
  589.  
  590.             
  591.             def __iter__(self):
  592.                 return self
  593.  
  594.             
  595.             def next(self):
  596.                 i = self.i
  597.                 self.i = i + 1
  598.                 return i
  599.  
  600.  
  601.         f = open(TESTFN, 'w')
  602.         
  603.         try:
  604.             f.write('a\nbbb\ncc\n')
  605.         finally:
  606.             f.close()
  607.  
  608.         f = open(TESTFN, 'r')
  609.         
  610.         try:
  611.             self.assertEqual(zip(IntsFrom(0), f, IntsFrom(-100)), [
  612.                 (0, 'a\n', -100),
  613.                 (1, 'bbb\n', -99),
  614.                 (2, 'cc\n', -98)])
  615.         finally:
  616.             f.close()
  617.             
  618.             try:
  619.                 unlink(TESTFN)
  620.             except OSError:
  621.                 pass
  622.  
  623.  
  624.         []([], [ (i,) for i in range(5) ])
  625.         
  626.         class NoGuessLen5:
  627.             
  628.             def __getitem__(self, i):
  629.                 if i >= 5:
  630.                     raise IndexError
  631.                 
  632.                 return i
  633.  
  634.  
  635.         
  636.         class Guess3Len5(NoGuessLen5):
  637.             
  638.             def __len__(self):
  639.                 return 3
  640.  
  641.  
  642.         
  643.         class Guess30Len5(NoGuessLen5):
  644.             
  645.             def __len__(self):
  646.                 return 30
  647.  
  648.  
  649.         self.assertEqual(len(Guess3Len5()), 3)
  650.         self.assertEqual(len(Guess30Len5()), 30)
  651.         self.assertEqual(zip(NoGuessLen5()), zip(range(5)))
  652.         self.assertEqual(zip(Guess3Len5()), zip(range(5)))
  653.         self.assertEqual(zip(Guess30Len5()), zip(range(5)))
  654.         expected = [ (i, i) for i in range(5) ]
  655.         for x in (NoGuessLen5(), Guess3Len5(), Guess30Len5()):
  656.             for y in (NoGuessLen5(), Guess3Len5(), Guess30Len5()):
  657.                 self.assertEqual(zip(x, y), expected)
  658.             
  659.         
  660.  
  661.     
  662.     def test_builtin_reduce(self):
  663.         add = add
  664.         import operator
  665.         self.assertEqual(reduce(add, SequenceClass(5)), 10)
  666.         self.assertEqual(reduce(add, SequenceClass(5), 42), 52)
  667.         self.assertRaises(TypeError, reduce, add, SequenceClass(0))
  668.         self.assertEqual(reduce(add, SequenceClass(0), 42), 42)
  669.         self.assertEqual(reduce(add, SequenceClass(1)), 0)
  670.         self.assertEqual(reduce(add, SequenceClass(1), 42), 42)
  671.         d = {
  672.             'one': 1,
  673.             'two': 2,
  674.             'three': 3 }
  675.         self.assertEqual(reduce(add, d), ''.join(d.keys()))
  676.  
  677.     
  678.     def test_unicode_join_endcase(self):
  679.         
  680.         class OhPhooey:
  681.             
  682.             def __init__(self, seq):
  683.                 self.it = iter(seq)
  684.                 self.i = 0
  685.  
  686.             
  687.             def __iter__(self):
  688.                 return self
  689.  
  690.             
  691.             def next(self):
  692.                 i = self.i
  693.                 self.i = i + 1
  694.                 if i == 2:
  695.                     return unicode('fooled you!')
  696.                 
  697.                 return self.it.next()
  698.  
  699.  
  700.         f = open(TESTFN, 'w')
  701.         
  702.         try:
  703.             f.write('a\n' + 'b\n' + 'c\n')
  704.         finally:
  705.             f.close()
  706.  
  707.         f = open(TESTFN, 'r')
  708.         
  709.         try:
  710.             got = ' - '.join(OhPhooey(f))
  711.             self.assertEqual(got, unicode('a\n - b\n - fooled you! - c\n'))
  712.         finally:
  713.             f.close()
  714.             
  715.             try:
  716.                 unlink(TESTFN)
  717.             except OSError:
  718.                 pass
  719.  
  720.  
  721.  
  722.     if not have_unicode:
  723.         
  724.         def test_unicode_join_endcase(self):
  725.             pass
  726.  
  727.     
  728.     
  729.     def test_in_and_not_in(self):
  730.         for sc5 in (IteratingSequenceClass(5), SequenceClass(5)):
  731.             for i in range(5):
  732.                 self.assert_(i in sc5)
  733.             
  734.             for i in ('abc', -1, 5, 42.420000000000002, (3, 4), [], {
  735.                 1: 1 }, 3 - (0.0+12.0j), sc5):
  736.                 self.assert_(i not in sc5)
  737.             
  738.         
  739.         self.assertRaises(TypeError, (lambda : 3 in 12))
  740.         self.assertRaises(TypeError, (lambda : 3 not in map))
  741.         d = {
  742.             'one': 1,
  743.             'two': 2,
  744.             'three': 3,
  745.             (0.0+1.0j): (0.0+2.0j) }
  746.         for k in d:
  747.             self.assert_(k in d)
  748.             self.assert_(k not in d.itervalues())
  749.         
  750.         for v in d.values():
  751.             self.assert_(v in d.itervalues())
  752.             self.assert_(v not in d)
  753.         
  754.         for k, v in d.iteritems():
  755.             self.assert_((k, v) in d.iteritems())
  756.             self.assert_((v, k) not in d.iteritems())
  757.         
  758.         f = open(TESTFN, 'w')
  759.         
  760.         try:
  761.             f.write('a\nb\nc\n')
  762.         finally:
  763.             f.close()
  764.  
  765.         f = open(TESTFN, 'r')
  766.         
  767.         try:
  768.             for chunk in 'abc':
  769.                 f.seek(0, 0)
  770.                 self.assert_(chunk not in f)
  771.                 f.seek(0, 0)
  772.                 self.assert_(chunk + '\n' in f)
  773.         finally:
  774.             f.close()
  775.             
  776.             try:
  777.                 unlink(TESTFN)
  778.             except OSError:
  779.                 pass
  780.  
  781.  
  782.  
  783.     
  784.     def test_countOf(self):
  785.         countOf = countOf
  786.         import operator
  787.         self.assertEqual(countOf([
  788.             1,
  789.             2,
  790.             2,
  791.             3,
  792.             2,
  793.             5], 2), 3)
  794.         self.assertEqual(countOf((1, 2, 2, 3, 2, 5), 2), 3)
  795.         self.assertEqual(countOf('122325', '2'), 3)
  796.         self.assertEqual(countOf('122325', '6'), 0)
  797.         self.assertRaises(TypeError, countOf, 42, 1)
  798.         self.assertRaises(TypeError, countOf, countOf, countOf)
  799.         d = {
  800.             'one': 3,
  801.             'two': 3,
  802.             'three': 3,
  803.             (0.0+1.0j): (0.0+2.0j) }
  804.         for k in d:
  805.             self.assertEqual(countOf(d, k), 1)
  806.         
  807.         self.assertEqual(countOf(d.itervalues(), 3), 3)
  808.         self.assertEqual(countOf(d.itervalues(), (0.0+2.0j)), 1)
  809.         self.assertEqual(countOf(d.itervalues(), (0.0+1.0j)), 0)
  810.         f = open(TESTFN, 'w')
  811.         
  812.         try:
  813.             f.write('a\nb\nc\nb\n')
  814.         finally:
  815.             f.close()
  816.  
  817.         f = open(TESTFN, 'r')
  818.         
  819.         try:
  820.             for letter, count in (('a', 1), ('b', 2), ('c', 1), ('d', 0)):
  821.                 f.seek(0, 0)
  822.                 self.assertEqual(countOf(f, letter + '\n'), count)
  823.         finally:
  824.             f.close()
  825.             
  826.             try:
  827.                 unlink(TESTFN)
  828.             except OSError:
  829.                 pass
  830.  
  831.  
  832.  
  833.     
  834.     def test_indexOf(self):
  835.         indexOf = indexOf
  836.         import operator
  837.         self.assertEqual(indexOf([
  838.             1,
  839.             2,
  840.             2,
  841.             3,
  842.             2,
  843.             5], 1), 0)
  844.         self.assertEqual(indexOf((1, 2, 2, 3, 2, 5), 2), 1)
  845.         self.assertEqual(indexOf((1, 2, 2, 3, 2, 5), 3), 3)
  846.         self.assertEqual(indexOf((1, 2, 2, 3, 2, 5), 5), 5)
  847.         self.assertRaises(ValueError, indexOf, (1, 2, 2, 3, 2, 5), 0)
  848.         self.assertRaises(ValueError, indexOf, (1, 2, 2, 3, 2, 5), 6)
  849.         self.assertEqual(indexOf('122325', '2'), 1)
  850.         self.assertEqual(indexOf('122325', '5'), 5)
  851.         self.assertRaises(ValueError, indexOf, '122325', '6')
  852.         self.assertRaises(TypeError, indexOf, 42, 1)
  853.         self.assertRaises(TypeError, indexOf, indexOf, indexOf)
  854.         f = open(TESTFN, 'w')
  855.         
  856.         try:
  857.             f.write('a\nb\nc\nd\ne\n')
  858.         finally:
  859.             f.close()
  860.  
  861.         f = open(TESTFN, 'r')
  862.         
  863.         try:
  864.             fiter = iter(f)
  865.             self.assertEqual(indexOf(fiter, 'b\n'), 1)
  866.             self.assertEqual(indexOf(fiter, 'd\n'), 1)
  867.             self.assertEqual(indexOf(fiter, 'e\n'), 0)
  868.             self.assertRaises(ValueError, indexOf, fiter, 'a\n')
  869.         finally:
  870.             f.close()
  871.             
  872.             try:
  873.                 unlink(TESTFN)
  874.             except OSError:
  875.                 pass
  876.  
  877.  
  878.         iclass = IteratingSequenceClass(3)
  879.         for i in range(3):
  880.             self.assertEqual(indexOf(iclass, i), i)
  881.         
  882.         self.assertRaises(ValueError, indexOf, iclass, -1)
  883.  
  884.     
  885.     def test_writelines(self):
  886.         f = file(TESTFN, 'w')
  887.         
  888.         try:
  889.             self.assertRaises(TypeError, f.writelines, None)
  890.             self.assertRaises(TypeError, f.writelines, 42)
  891.             f.writelines([
  892.                 '1\n',
  893.                 '2\n'])
  894.             f.writelines(('3\n', '4\n'))
  895.             f.writelines({
  896.                 '5\n': None })
  897.             f.writelines({ })
  898.             
  899.             class Iterator:
  900.                 
  901.                 def __init__(self, start, finish):
  902.                     self.start = start
  903.                     self.finish = finish
  904.                     self.i = self.start
  905.  
  906.                 
  907.                 def next(self):
  908.                     if self.i >= self.finish:
  909.                         raise StopIteration
  910.                     
  911.                     result = str(self.i) + '\n'
  912.                     self.i += 1
  913.                     return result
  914.  
  915.                 
  916.                 def __iter__(self):
  917.                     return self
  918.  
  919.  
  920.             
  921.             class Whatever:
  922.                 
  923.                 def __init__(self, start, finish):
  924.                     self.start = start
  925.                     self.finish = finish
  926.  
  927.                 
  928.                 def __iter__(self):
  929.                     return Iterator(self.start, self.finish)
  930.  
  931.  
  932.             f.writelines(Whatever(6, 6 + 2000))
  933.             f.close()
  934.             f = file(TESTFN)
  935.             expected = [ str(i) + '\n' for i in range(1, 2006) ]
  936.             self.assertEqual(list(f), expected)
  937.         finally:
  938.             f.close()
  939.             
  940.             try:
  941.                 unlink(TESTFN)
  942.             except OSError:
  943.                 pass
  944.  
  945.  
  946.  
  947.     
  948.     def test_unpack_iter(self):
  949.         (a, b) = (1, 2)
  950.         self.assertEqual((a, b), (1, 2))
  951.         (a, b, c) = IteratingSequenceClass(3)
  952.         self.assertEqual((a, b, c), (0, 1, 2))
  953.         
  954.         try:
  955.             (a, b) = IteratingSequenceClass(3)
  956.         except ValueError:
  957.             pass
  958.  
  959.         self.fail('should have raised ValueError')
  960.         
  961.         try:
  962.             (a, b, c) = IteratingSequenceClass(2)
  963.         except ValueError:
  964.             pass
  965.  
  966.         self.fail('should have raised ValueError')
  967.         
  968.         try:
  969.             (a, b, c) = len
  970.         except TypeError:
  971.             pass
  972.  
  973.         self.fail('should have raised TypeError')
  974.         (a, b, c) = {
  975.             1: 42,
  976.             2: 42,
  977.             3: 42 }.itervalues()
  978.         self.assertEqual((a, b, c), (42, 42, 42))
  979.         f = open(TESTFN, 'w')
  980.         lines = ('a\n', 'bb\n', 'ccc\n')
  981.         
  982.         try:
  983.             for line in lines:
  984.                 f.write(line)
  985.         finally:
  986.             f.close()
  987.  
  988.         f = open(TESTFN, 'r')
  989.         
  990.         try:
  991.             (a, b, c) = f
  992.             self.assertEqual((a, b, c), lines)
  993.         finally:
  994.             f.close()
  995.             
  996.             try:
  997.                 unlink(TESTFN)
  998.             except OSError:
  999.                 pass
  1000.  
  1001.  
  1002.         (a, b) = IteratingSequenceClass(2)
  1003.         (c,) = {
  1004.             42: 24 }
  1005.         self.assertEqual((a, b, c), (0, 1, 42))
  1006.         
  1007.         class C(object):
  1008.             count = 0
  1009.             
  1010.             def __new__(cls):
  1011.                 cls.count += 1
  1012.                 return object.__new__(cls)
  1013.  
  1014.             
  1015.             def __del__(self):
  1016.                 cls = self.__class__
  1017.                 if not cls.count > 0:
  1018.                     raise AssertionError
  1019.                 cls.count -= 1
  1020.  
  1021.  
  1022.         x = C()
  1023.         self.assertEqual(C.count, 1)
  1024.         del x
  1025.         self.assertEqual(C.count, 0)
  1026.         l = [
  1027.             C(),
  1028.             C(),
  1029.             C()]
  1030.         self.assertEqual(C.count, 3)
  1031.         
  1032.         try:
  1033.             (a, b) = iter(l)
  1034.         except ValueError:
  1035.             pass
  1036.  
  1037.         del l
  1038.         self.assertEqual(C.count, 0)
  1039.  
  1040.     
  1041.     def test_sinkstate_list(self):
  1042.         a = range(5)
  1043.         b = iter(a)
  1044.         self.assertEqual(list(b), range(5))
  1045.         a.extend(range(5, 10))
  1046.         self.assertEqual(list(b), [])
  1047.  
  1048.     
  1049.     def test_sinkstate_tuple(self):
  1050.         a = (0, 1, 2, 3, 4)
  1051.         b = iter(a)
  1052.         self.assertEqual(list(b), range(5))
  1053.         self.assertEqual(list(b), [])
  1054.  
  1055.     
  1056.     def test_sinkstate_string(self):
  1057.         a = 'abcde'
  1058.         b = iter(a)
  1059.         self.assertEqual(list(b), [
  1060.             'a',
  1061.             'b',
  1062.             'c',
  1063.             'd',
  1064.             'e'])
  1065.         self.assertEqual(list(b), [])
  1066.  
  1067.     
  1068.     def test_sinkstate_sequence(self):
  1069.         a = SequenceClass(5)
  1070.         b = iter(a)
  1071.         self.assertEqual(list(b), range(5))
  1072.         a.n = 10
  1073.         self.assertEqual(list(b), [])
  1074.  
  1075.     
  1076.     def test_sinkstate_callable(self):
  1077.         
  1078.         def spam(state = [
  1079.             0]):
  1080.             i = state[0]
  1081.             state[0] = i + 1
  1082.             if i == 10:
  1083.                 raise AssertionError, "shouldn't have gotten this far"
  1084.             
  1085.             return i
  1086.  
  1087.         b = iter(spam, 5)
  1088.         self.assertEqual(list(b), range(5))
  1089.         self.assertEqual(list(b), [])
  1090.  
  1091.     
  1092.     def test_sinkstate_dict(self):
  1093.         a = {
  1094.             1: 1,
  1095.             2: 2,
  1096.             0: 0,
  1097.             4: 4,
  1098.             3: 3 }
  1099.         for b in (iter(a), a.iterkeys(), a.iteritems(), a.itervalues()):
  1100.             b = iter(a)
  1101.             self.assertEqual(len(list(b)), 5)
  1102.             self.assertEqual(list(b), [])
  1103.         
  1104.  
  1105.     
  1106.     def test_sinkstate_yield(self):
  1107.         
  1108.         def gen():
  1109.             for i in range(5):
  1110.                 yield i
  1111.             
  1112.  
  1113.         b = gen()
  1114.         self.assertEqual(list(b), range(5))
  1115.         self.assertEqual(list(b), [])
  1116.  
  1117.     
  1118.     def test_sinkstate_range(self):
  1119.         a = xrange(5)
  1120.         b = iter(a)
  1121.         self.assertEqual(list(b), range(5))
  1122.         self.assertEqual(list(b), [])
  1123.  
  1124.     
  1125.     def test_sinkstate_enumerate(self):
  1126.         a = range(5)
  1127.         e = enumerate(a)
  1128.         b = iter(e)
  1129.         self.assertEqual(list(b), zip(range(5), range(5)))
  1130.         self.assertEqual(list(b), [])
  1131.  
  1132.  
  1133.  
  1134. def test_main():
  1135.     run_unittest(TestCase)
  1136.  
  1137. if __name__ == '__main__':
  1138.     test_main()
  1139.  
  1140.